package zhihuilan.controlle.wechatMini;

import cn.binarywang.wx.miniapp.api.WxMaService;
import com.alibaba.fastjson2.JSONObject;
import com.baomidou.mybatisplus.extension.plugins.pagination.Page;
import lombok.extern.slf4j.Slf4j;
import me.chanjar.weixin.common.error.WxErrorException;
import org.springframework.beans.BeanUtils;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.util.ObjectUtils;
import org.springframework.web.bind.annotation.PostMapping;
import org.springframework.web.bind.annotation.RequestBody;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.RestController;
import org.springframework.web.context.request.RequestContextHolder;
import org.springframework.web.context.request.ServletRequestAttributes;
import zhihuilan.common.WxMiniResponse;
import zhihuilan.common.enums.ResultEnum;
import zhihuilan.common.utils.ToolsUtils;
import zhihuilan.controlle.BasicController;
import zhihuilan.dto.MyAcquisitionDto;
import zhihuilan.dto.MyAcquisitionMsgDto;
import zhihuilan.dto.WxMiniPageDto;
import zhihuilan.entity.MyAcquisition;
import zhihuilan.entity.MyAcquisitionMsg;
import zhihuilan.entity.MyAcquisitionMsgExtra;
import zhihuilan.entity.MyConfig;
import zhihuilan.params.StaticParam;
import zhihuilan.params.query.MyAcquisitionMsgQueryParam;
import zhihuilan.params.query.MyAcquisitionQueryParam;
import zhihuilan.params.query.RegisterQueryParam;
import zhihuilan.params.save.MyAcquisitionMsgSaveParam;
import zhihuilan.params.save.MyAcquisitionSaveParam;
import zhihuilan.service.MyAcquisitionMsgService;
import zhihuilan.service.MyAcquisitionService;
import zhihuilan.service.MyConfigService;

import javax.annotation.Resource;
import javax.servlet.http.HttpServletRequest;
import java.net.UnknownHostException;
import java.util.Date;
import java.util.List;
import java.util.stream.Collectors;


/**
 * 小程序端API </p>
 * 接口说明：</p>
 *
 * @Module 采购相关接口模块
 * @Author chenk
 * @Version 1.0.1 (2025-02-24)
 */
@Slf4j
@RestController
@RequestMapping("/app/Acquisition")
public class MyAcquisitionController extends BasicController {


    @Resource
    private MyAcquisitionService myAcquisitionService;

    @Autowired
    WxMaService wxMaService;

    @Resource
    private MyConfigService myConfigService;

    @Resource
    private MyAcquisitionMsgService myAcquisitionMsgService;

    /**
     * 根据前端传入的参数，查询采购信息列表；
     *
     * @param queryParam 采购查询参数【MyAcquisitionQueryParam】标准查询参数类；
     * @return 标准响应体封装基础数据转换成前端数据；
     * @ApiNote 使用时请使用返回前端数据的封装类；因为小程序前端字段名和本接口服务层返回的数据字段不一致；必须使用封装的返回数据类；
     * @Author chenk
     * @Version 1.0.1
     */
    @PostMapping("/getAcquisitionList")
    public WxMiniResponse getAcquisitionList(@RequestBody MyAcquisitionQueryParam queryParam) {
        if (!this.isCheckLogin(queryParam.getGuid())) {
            //如果用户未登陆，提示用户未登陆信息，并且返回未登陆的枚举编码；
//            return WxMiniResponse.error(ResultEnum.UNLOGIN.getKey(), ResultEnum.UNLOGIN.getValue());
        }
        System.out.println(queryParam);
        Page<MyAcquisition> page = myAcquisitionService.selectPageList(queryParam);
//        Page<MyAcquisition> selectPage = this.myAcquisitionService.selectMyAcquisition(queryParam);
        WxMiniPageDto<MyAcquisitionDto> wxMiniPageDto = new WxMiniPageDto(page.getCurrent(), page.getSize());
        BeanUtils.copyProperties(page, wxMiniPageDto);
        List<MyAcquisitionDto> convertList = page.getRecords().stream().map(po -> {
            MyAcquisitionDto myAcquisitionDto = new MyAcquisitionDto();
            BeanUtils.copyProperties(po, myAcquisitionDto);
            return myAcquisitionDto;
        }).collect(Collectors.toList());
        wxMiniPageDto.setData(convertList);
        return WxMiniResponse.ok(wxMiniPageDto);

//        List<MyAcquisitionDto> convertList = page.getRecords().stream().map(po -> {
//            MyAcquisitionDto myAcquisitionDto = new MyAcquisitionDto();
//            BeanUtils.copyProperties(po, myAcquisitionDto);
//            return myAcquisitionDto;
//        }).collect(Collectors.toList());
//        Page<MyAcquisitionDto> resultPage = new Page<>(page.getCurrent(), page.getSize()); // 第1页，每页10条数据
//        BeanUtils.copyProperties(page, resultPage);
//        resultPage.setRecords(convertList);
//        return WxMiniResponse.ok(convertList);
    }

    /**
     * 保存采购信息；
     *
     * @param saveParam 采购保存参数【MyAcquisitionSaveParam】标准采购保存参数类；
     * @return 标准响应体封装基础数据转换成前端数据；
     * @ApiNote 使用时请使用返回前端数据的封装类；因为小程序前端字段名和本接口服务层返回的数据字段不一致；必须使用封装的返回数据类；
     * @Author chenk
     * @Version 1.0.1
     */
    @PostMapping("/addAcquisition")
    public WxMiniResponse addAcquisition(@RequestBody MyAcquisitionSaveParam saveParam) {
        System.out.println(saveParam);
        if (!this.isCheckLogin(saveParam.getGuid())) {
            //如果用户未登陆，提示用户未登陆信息，并且返回未登陆的枚举编码；
            return WxMiniResponse.error(ResultEnum.UNLOGIN.getKey(), ResultEnum.UNLOGIN.getValue());
        }
//        if (!ObjectUtils.isEmpty(saveParam.getContent())) {
//            try {
//                try {
//                    String checkFt = ToolsUtils.verifymsg(saveParam.getContent(), currentStaff.getOpenid(), wxMaService);
//                    JSONObject jsonObject = JSONObject.parseObject(checkFt);
//                    if ((jsonObject.getJSONObject("result").get("suggest")).equals("risky")) {
//                        return WxMiniResponse.error(ResultEnum.ERROR.getKey(), "请文明言论");
//                    }
//                } catch (UnknownHostException e) {
//                    return WxMiniResponse.error(ResultEnum.ERROR.getKey(), e.getMessage());
//                }
//            } catch (WxErrorException e) {
//                return WxMiniResponse.error(ResultEnum.ERROR.getKey(), e.getMessage());
//            }
//        }
        String errorMsg = this.isValidContent(saveParam.getContent());
        if (!ObjectUtils.isEmpty(errorMsg))
            return WxMiniResponse.error(ResultEnum.ERROR.getKey(), errorMsg);
        Integer nowTime = Integer.parseInt(new Date().getTime() / 1000 + "");
        MyAcquisitionQueryParam queryParam = new MyAcquisitionQueryParam();
        queryParam.setStaffId(currentStaff.getId());
        queryParam.setCreateTime(Integer.parseInt(ToolsUtils.getTodayZeroTime() / 1000 + ""));
        Long todaySendCount = myAcquisitionService.getTodaySendCount(queryParam);
        MyConfig myConfig = myConfigService.selectByName("acquisitionNumber");
        if (todaySendCount >= Long.parseLong(myConfig.getValue())) {
            return WxMiniResponse.error(ResultEnum.ERROR.getKey(), "每天限制发" + myConfig.getValue() + "条求购！");
        }
        saveParam.setStaffId(currentStaff.getId());
        saveParam.setUserName(currentStaff.getUserreal());
        saveParam.setUserLogo(currentStaff.getHeadimgurl());
        saveParam.setStatus(1);
        saveParam.setCreateTime(nowTime);
        saveParam.setCallback(0);
        saveParam.setUpdateTime(saveParam.getEndTime());
        saveParam.setCreateUser(currentStaff.getId() + "");
        if (!ObjectUtils.isEmpty(currentStaff.getInvitecode()) && !ObjectUtils.isEmpty(currentStaff.getOutinvitetime())) {
            if (currentStaff.getOutinvitetime() > nowTime)
                saveParam.setInvitecode(Integer.parseInt(currentStaff.getInvitecode()));
        } else {
            saveParam.setInvitecode(1);
        }
        String ip = ToolsUtils.getIP();
        saveParam.setIp(ip);
        MyAcquisition result = myAcquisitionService.addEntity(saveParam);
        return WxMiniResponse.ok("添加成功");
    }

    /**
     * 删除采购信息；
     *
     * @param deleteParam 传入参数只会识别参数中的ID字段值；其它字段自动过滤；
     * @return 标准响应体封装基础数据转换成前端数据；
     * @ApiNote 使用时请使用返回前端数据的封装类；因为小程序前端字段名和本接口服务层返回的数据字段不一致；必须使用封装的返回数据类；
     * @Author chenk
     * @Version 1.0.1
     */
    @PostMapping("/delAcquisition")
    public WxMiniResponse delAcquisition(@RequestBody MyAcquisitionSaveParam deleteParam) {
        // TDD
        if (!this.isCheckLogin(deleteParam.getGuid())) {
            //如果用户未登陆，提示用户未登陆信息，并且返回未登陆的枚举编码；
            return WxMiniResponse.error(ResultEnum.UNLOGIN.getKey(), ResultEnum.UNLOGIN.getValue());
        }
        if (ObjectUtils.isEmpty(deleteParam) || ObjectUtils.isEmpty(deleteParam.getId())) {
            return WxMiniResponse.error(ResultEnum.ERROR.getKey(), "传入参数ID为空！");
        }
        MyAcquisition myAcquisition = myAcquisitionService.selectById(deleteParam.getId());
        if (ObjectUtils.isEmpty(myAcquisition)) {
            return WxMiniResponse.error(ResultEnum.ERROR.getKey(), "您删除的采购信息不存在或已经被删除！");
        }
        Boolean result = myAcquisitionService.deleteById(deleteParam.getId());
        if (result)
            return WxMiniResponse.ok("删除成功!");
        else {
            return WxMiniResponse.error(ResultEnum.ERROR.getKey(), "删除失败");
        }
    }

    /**
     * 采购中标api；
     *
     * @param queryParam 传入参数只识别ID和status字段；
     * @return 标准响应体封装基础数据转换成前端数据；
     * @ApiNote 使用时请使用返回前端数据的封装类；因为小程序前端字段名和本接口服务层返回的数据字段不一致；必须使用封装的返回数据类；
     * @Author chenk
     * @Version 1.0.1
     */
    @PostMapping("/zhongAcquisitionMsg")
    public WxMiniResponse zhongAcquisitionMsg(@RequestBody MyAcquisitionMsgQueryParam queryParam) {
        if (ObjectUtils.isEmpty(queryParam.getStatus())) {
            queryParam.setStatus(1);
        }
        // TDD
        if (!this.isCheckLogin(queryParam.getGuid())) {
            //如果用户未登陆，提示用户未登陆信息，并且返回未登陆的枚举编码；
            return WxMiniResponse.error(ResultEnum.UNLOGIN.getKey(), ResultEnum.UNLOGIN.getValue());
        }
        if (ObjectUtils.isEmpty(queryParam)) {
            return WxMiniResponse.error(ResultEnum.ERROR.getKey(), "传入参数为空！");
        }
        if (ObjectUtils.isEmpty(queryParam.getId())) {
            return WxMiniResponse.error(ResultEnum.ERROR.getKey(), "传入参数ID为空！");
        }
        MyAcquisitionMsg myAcquisitionMsg = myAcquisitionMsgService.selectById(queryParam.getId());
        if (!ObjectUtils.isEmpty(myAcquisitionMsg)) {
            MyAcquisition myAcquisition = myAcquisitionService.selectById(myAcquisitionMsg.getPid());
            if (!ObjectUtils.isEmpty(myAcquisition) && myAcquisition.getStatus().equals(1)) {
                myAcquisitionMsg.setStatus(queryParam.getStatus());
                myAcquisitionMsg = myAcquisitionMsgService.updateEntity(myAcquisitionMsg);
                if (!ObjectUtils.isEmpty(myAcquisitionMsg)) {
                    return WxMiniResponse.ok("修改成功!");
                }
            }
        }
        return WxMiniResponse.error(ResultEnum.ERROR.getKey(), "修改失败!");
    }

    /**
     * 获取报价的求购列表	api；
     *
     * @param queryParam 传入参数查询关键字；
     * @return 标准响应体封装基础数据转换成前端数据；
     * @ApiNote 使用时请使用返回前端数据的封装类；因为小程序前端字段名和本接口服务层返回的数据字段不一致；必须使用封装的返回数据类；
     * @Author chenk
     * @Version 1.0.1
     */
    @PostMapping("/getMyAcquisitionList")
    public WxMiniResponse getMyAcquisitionList(@RequestBody MyAcquisitionQueryParam queryParam) {
        // TDD
        if (!this.isCheckLogin(queryParam.getGuid())) {
            //如果用户未登陆，提示用户未登陆信息，并且返回未登陆的枚举编码；
//            return WxMiniResponse.error(ResultEnum.UNLOGIN.getKey(), ResultEnum.UNLOGIN.getValue());
        }
        if (!ObjectUtils.isEmpty(currentStaff)) {
            queryParam.setStaffId(currentStaff.getId());
        }
        Page<MyAcquisition> selectPage = this.myAcquisitionService.selectMyAcquisition(queryParam);
        WxMiniPageDto<MyAcquisitionDto> wxMiniPageDto = new WxMiniPageDto(selectPage.getCurrent(), selectPage.getSize());
        BeanUtils.copyProperties(selectPage, wxMiniPageDto);
        List<MyAcquisitionDto> convertList = selectPage.getRecords().stream().map(po -> {
            MyAcquisitionDto myAcquisitionDto = new MyAcquisitionDto();
            BeanUtils.copyProperties(po, myAcquisitionDto);
            return myAcquisitionDto;
        }).collect(Collectors.toList());
        wxMiniPageDto.setData(convertList);
        return WxMiniResponse.ok(wxMiniPageDto);
    }

    /**
     * 获取求购信息	api；
     *
     * @param queryParam 传入参数只识别ID；
     * @return 标准响应体封装基础数据转换成前端数据；
     * @ApiNote 使用时请使用返回前端数据的封装类；因为小程序前端字段名和本接口服务层返回的数据字段不一致；必须使用封装的返回数据类；
     * @Author chenk
     * @Version 1.0.1
     */
    @PostMapping("/getAcquisitionInfo")
    public WxMiniResponse getAcquisitionInfo(@RequestBody MyAcquisitionQueryParam queryParam) {
        // TDD
        if (!this.isCheckLogin(queryParam.getGuid())) {
            //如果用户未登陆，提示用户未登陆信息，并且返回未登陆的枚举编码；
//            return WxMiniResponse.error(ResultEnum.UNLOGIN.getKey(), ResultEnum.UNLOGIN.getValue());
        }
        if (ObjectUtils.isEmpty(queryParam) || ObjectUtils.isEmpty(queryParam.getId())) {
            return WxMiniResponse.error(ResultEnum.ERROR.getKey(), "传入参数为空");
        }
        MyAcquisition myAcquisition = myAcquisitionService.selectById(queryParam.getId());
        if (ObjectUtils.isEmpty(myAcquisition)) {
            return WxMiniResponse.error(ResultEnum.ERROR.getKey(), "获取采购信息失败", "获取采购信息失败");
        }
        if (!ObjectUtils.isEmpty(currentStaff) && myAcquisition.getStatus().equals(1)) {
            if (currentStaff.getId().equals(myAcquisition.getStaffId())) {
                myAcquisition.setSender(myAcquisition.getCallback());
                myAcquisition = myAcquisitionService.updateEntity(myAcquisition);
            }
        }
        MyAcquisitionDto dto = new MyAcquisitionDto();
        BeanUtils.copyProperties(myAcquisition, dto);
        return WxMiniResponse.ok(dto);
    }

    /**
     * 发表求购回复	api；
     *
     * @param saveParam 传入参数使用前端实体对象类【MyAcquisitionMsgSaveParam】；
     * @return 标准响应体封装基础数据转换成前端数据；
     * @ApiNote 使用时请使用返回前端数据的封装类；因为小程序前端字段名和本接口服务层返回的数据字段不一致；必须使用封装的返回数据类；
     * @Author chenk
     * @Version 1.0.1
     */
    @PostMapping("/addAcquisitionMsg")
    public WxMiniResponse addAcquisitionMsg(@RequestBody MyAcquisitionMsgSaveParam saveParam) {
        // TDD
        if (!this.isCheckLogin(saveParam.getGuid())) {
            //如果用户未登陆，提示用户未登陆信息，并且返回未登陆的枚举编码；
            return WxMiniResponse.error(ResultEnum.UNLOGIN.getKey(), ResultEnum.UNLOGIN.getValue());
        }
        if (!ObjectUtils.isEmpty(saveParam.getContent())) {
            try {
                try {
                    String checkFt = ToolsUtils.verifymsg(saveParam.getContent(), currentStaff.getOpenid(), wxMaService);
                    JSONObject jsonObject = JSONObject.parseObject(checkFt);
                    if ((jsonObject.getJSONObject("result").get("suggest")).equals("risky")) {
                        return WxMiniResponse.error(ResultEnum.ERROR.getKey(), "请文明言论");
                    }
                } catch (UnknownHostException e) {
                    return WxMiniResponse.error(ResultEnum.ERROR.getKey(), e.getMessage());
                }
            } catch (WxErrorException e) {
                return WxMiniResponse.error(ResultEnum.ERROR.getKey(), e.getMessage());
            }
        }
        Integer nowTime = Integer.parseInt(new Date().getTime() / 1000 + "");
        MyAcquisitionQueryParam queryParam = new MyAcquisitionQueryParam();
        queryParam.setStaffId(currentStaff.getId());
        queryParam.setCreateTime(nowTime);
        saveParam.setStaffId(currentStaff.getId());
        saveParam.setStatus(1);
        saveParam.setCreateTime(nowTime);
        saveParam.setCreateUser(currentStaff.getId() + "");
        String ip = ToolsUtils.getIP();
        saveParam.setIp(ip);
        if (ObjectUtils.isEmpty(saveParam.getId()) || saveParam.getId().equals(0)) {
            MyAcquisitionMsg myAcquisitionMsg = new MyAcquisitionMsg();
            BeanUtils.copyProperties(saveParam, myAcquisitionMsg);
            myAcquisitionMsg = this.myAcquisitionMsgService.addEntity(myAcquisitionMsg);
            if (!ObjectUtils.isEmpty(myAcquisitionMsg)) {
                MyAcquisition myAcquisition = this.myAcquisitionService.selectById(myAcquisitionMsg.getPid());
                if (!ObjectUtils.isEmpty(myAcquisition)) {
                    myAcquisition.setCallback(myAcquisition.getCallback() + 1);
                    this.myAcquisitionService.updateEntity(myAcquisition);
                }
            } else {
                return WxMiniResponse.error(3122, "操作失败");
            }
        } else {
            MyAcquisitionMsg myAcquisitionMsg = new MyAcquisitionMsg();
            BeanUtils.copyProperties(saveParam, myAcquisitionMsg);
            myAcquisitionMsg = this.myAcquisitionMsgService.updateEntity(myAcquisitionMsg);
            if (ObjectUtils.isEmpty(myAcquisitionMsg)) {
                return WxMiniResponse.error(3122, "操作失败");
            }
        }
        return WxMiniResponse.ok("添加成功！");
    }

    /**
     * 获取求购回复列表	api；
     *
     * @param queryParam 传入参数只识别pid和home、page,pageSize四个字段；
     * @return 标准响应体封装基础数据转换成前端数据；
     * @ApiNote 使用时请使用返回前端数据的封装类；因为小程序前端字段名和本接口服务层返回的数据字段不一致；必须使用封装的返回数据类；
     * @Author chenk
     * @Version 1.0.1
     */
    @PostMapping("/getAcquisitionMsgList")
    public WxMiniResponse getAcquisitionMsgList(@RequestBody MyAcquisitionMsgQueryParam queryParam) {
        // TDD
        if (!this.isCheckLogin(queryParam.getGuid())) {
            //如果用户未登陆，提示用户未登陆信息，并且返回未登陆的枚举编码；
//            return WxMiniResponse.error(ResultEnum.UNLOGIN.getKey(), ResultEnum.UNLOGIN.getValue());
        }
        if (ObjectUtils.isEmpty(queryParam) || ObjectUtils.isEmpty(queryParam.getPid())) {
            return WxMiniResponse.error(ResultEnum.ERROR.getKey(), "传入参数为空");
        }

        MyAcquisition myAcquisition = this.myAcquisitionService.selectById(queryParam.getPid());
        WxMiniPageDto<MyAcquisitionMsgDto> page =new WxMiniPageDto<>();
        if (!ObjectUtils.isEmpty(currentStaff)) {
            if (!ObjectUtils.isEmpty(myAcquisition)) {
                if (myAcquisition.getStaffId().equals(currentStaff.getId())) {
                    queryParam.setHome(0);
                }
            }
            if (queryParam.getHome().equals(1)) {
                queryParam.setStaffId(currentStaff.getId());

            } else {
                queryParam.setStatus(1);
            }
            page = this.myAcquisitionMsgService.selectMyAcquisitionMsgPage(queryParam);
        }


        return WxMiniResponse.ok(page);
    }

    /**
     * 获取求购信息	api；
     *
     * @param queryParam 传入参数只识别id字段；
     * @return 标准响应体封装基础数据转换成前端数据；
     * @ApiNote 使用时请使用返回前端数据的封装类；因为小程序前端字段名和本接口服务层返回的数据字段不一致；必须使用封装的返回数据类；
     * @Author chenk
     * @Version 1.0.1
     */
    @PostMapping("/getAcquisitionInfoMsg")
    public WxMiniResponse getAcquisitionInfoMsg(@RequestBody MyAcquisitionMsgQueryParam queryParam) {
        // TDD
        if (!this.isCheckLogin(queryParam.getGuid())) {
            //如果用户未登陆，提示用户未登陆信息，并且返回未登陆的枚举编码；
//            return WxMiniResponse.error(ResultEnum.UNLOGIN.getKey(), ResultEnum.UNLOGIN.getValue());
        }
        if (ObjectUtils.isEmpty(queryParam) || ObjectUtils.isEmpty(queryParam.getId())) {
            return WxMiniResponse.error(ResultEnum.ERROR.getKey(), "传入参数为空");
        }
        MyAcquisitionMsg myAcquisitionMsg = this.myAcquisitionMsgService.selectById(queryParam.getId());
        MyAcquisitionMsgDto dto = new MyAcquisitionMsgDto();
        BeanUtils.copyProperties(myAcquisitionMsg, dto);
        if (!ObjectUtils.isEmpty(myAcquisitionMsg) && myAcquisitionMsg.getStatus().equals(1)) {
            return WxMiniResponse.ok(dto);
        } else {
            return WxMiniResponse.ok(null);
        }
    }

    /**
     * 删除求购回复信息	api；
     *
     * @param queryParam 传入参数只识别id字段；
     * @return 标准响应体封装基础数据转换成前端数据；
     * @ApiNote 使用时请使用返回前端数据的封装类；因为小程序前端字段名和本接口服务层返回的数据字段不一致；必须使用封装的返回数据类；
     * @Author chenk
     * @Version 1.0.1
     */
    @PostMapping("/delAcquisitionMgs")
    public WxMiniResponse delAcquisitionMgs(@RequestBody MyAcquisitionMsgQueryParam queryParam) {
        // TDD
        if (!this.isCheckLogin(queryParam.getGuid())) {
            //如果用户未登陆，提示用户未登陆信息，并且返回未登陆的枚举编码；
            return WxMiniResponse.error(ResultEnum.UNLOGIN.getKey(), ResultEnum.UNLOGIN.getValue());
        }
        if (ObjectUtils.isEmpty(queryParam) || ObjectUtils.isEmpty(queryParam.getId())) {
            return WxMiniResponse.error(ResultEnum.ERROR.getKey(), "传入参数为空");
        }
        MyAcquisitionMsg myAcquisitionMsg = this.myAcquisitionMsgService.selectById(queryParam.getId());
        if (!ObjectUtils.isEmpty(myAcquisitionMsg)) {
            if (myAcquisitionMsg.getStaffId().equals(currentStaff.getId())) {
                MyAcquisition myAcquisition = this.myAcquisitionService.selectById(myAcquisitionMsg.getPid());
                if (!ObjectUtils.isEmpty(myAcquisition)) {
                    myAcquisition.setCallback(myAcquisition.getCallback() - 1);
                    this.myAcquisitionService.updateEntity(myAcquisition);
                }
                this.myAcquisitionMsgService.deleteById(myAcquisitionMsg.getId());
            } else {
                myAcquisitionMsg.setStatus(0);
                this.myAcquisitionMsgService.updateEntity(myAcquisitionMsg);
            }
            return WxMiniResponse.ok("删除成功!");
        }
        return WxMiniResponse.ok("已经删除!");
    }

    /**
     * 校验求购信息是否存在；
     *
     * @return 标准响应体封装基础数据转换成前端数据；
     * @ApiNote 使用时请使用返回前端数据的封装类；因为小程序前端字段名和本接口服务层返回的数据字段不一致；必须使用封装的返回数据类；
     * @Author chenk
     * @Version 1.0.1
     */
    @PostMapping("/checkAcquisitionInfo")
    public WxMiniResponse checkAcquisitionInfo(@RequestBody StaticParam param) {
        if(ObjectUtils.isEmpty(param)) {
            return WxMiniResponse.error(ResultEnum.ERROR.getKey(), "传入参数为空","传入参数为空");
        }
        if(ObjectUtils.isEmpty(param.getId())) {
            return WxMiniResponse.error(ResultEnum.ERROR.getKey(), "传入参数id为空","传入参数id为空");
        }
        MyAcquisition myAcquisition = myAcquisitionService.selectById(param.getId());
        if (!ObjectUtils.isEmpty(myAcquisition)) {
            if (myAcquisition.getStatus().equals(0)) {
                return WxMiniResponse.error(ResultEnum.ERROR2012.getKey(), "信息不存在或已被删除","信息不存在或已被删除");
            }
        }else{
            return WxMiniResponse.error(ResultEnum.ERROR2012.getKey(), "信息不存在或已被删除","信息不存在或已被删除");
        }
        return WxMiniResponse.ok();
    }
}
